package com.cgy.utils.cmd.utils;


import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 正则匹配工具类
 *
 * @author CH
 */
public class PatternUtils {

    /**
     * **************************
     * 功能说明: 是否满足正则
     * **************************
     * <p>
     *
     * <pre>
     * e.g.""
     * </pre>
     * </p>
     *
     * @param src   源数据
     * @param regex 正则
     * @return
     * @author CH
     * @since 2017年12月18日
     */
    public static boolean isContainer(String src, String regex) {
        boolean isResult = false;
        try {
            if (StringUtils.isNotBlank(src) && StringUtils.isNotBlank(regex)) {
                Pattern pattern = Pattern.compile(regex.replaceAll("\\s", ""));
                Matcher matcher = pattern.matcher(src);
                isResult = matcher.find();
            }
        } catch (Exception e) {
        }
        return isResult;
    }

    /**
     * **************************
     * 功能说明: 是否满足正则
     * **************************
     * <p>
     *
     * <pre>
     * e.g.""
     * </pre>
     * </p>
     *
     * @param t     源数据
     * @param regex 正则
     * @return
     * @author CH
     * @since 2017年12月18日
     */
    @SuppressWarnings({"unused", "unchecked"})
    public static <T> Object isContainer(T t, String regex) {
        boolean isResult = false;
        try {
            if (t instanceof String) {
                String src = (String) t;
                if (StringUtils.isNotBlank(src) && StringUtils.isNotBlank(regex)) {
                    Pattern pattern = Pattern.compile(regex.replaceAll("\\s", ""));
                    Matcher matcher = pattern.matcher(src);
                    if (matcher.find()) {
                        return "";
                    }
                }
            } else if (t instanceof Map) {
                Map<String, String> map = new HashMap<>();
                if (null != t) {
                    Map<String, String> src = (Map<String, String>) t;
                    for (String key : src.keySet()) {
                        if (!isContainer(key, regex)) {
                            map.put(key, src.get(key));
                        }
                    }
                    return map;
                } else {
                    return null;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return isResult;
    }

    /**
     * 获取匹配部分
     *  @param srcValue
     * @param regex
     * @return
     */
    public static List<String> getMatchPart(String srcValue, String regex) {
        List<String> matchResult = new ArrayList<>();
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(srcValue);
        while(matcher.find()) {
            matchResult.add(matcher.group());
        }
        return matchResult;
    }

    /**
     * 判断字段是否为空 符合返回ture
     *
     * @param str
     * @return boolean
     */
    public static synchronized boolean StrisNull(String str) {
        return null == str || str.trim().length() <= 0 ? true : false;
    }

    /**
     * 判断字段是非空 符合返回ture
     *
     * @param str
     * @return boolean
     */
    public static boolean StrNotNull(String str) {
        return !StrisNull(str);
    }

    /**
     * 字符串null转空
     *
     * @param str
     * @return boolean
     */
    public static String nulltoStr(String str) {
        return StrisNull(str) ? "" : str;
    }

    /**
     * 字符串null赋值默认值
     *
     * @param str    目标字符串
     * @param defaut 默认值
     * @return String
     */
    public static String nulltoStr(String str, String defaut) {
        return StrisNull(str) ? defaut : str;
    }


    /**
     * 判断字段是否超长
     * 字串为空返回fasle, 超过长度{leng}返回ture 反之返回false
     *
     * @param str
     * @param leng
     * @return boolean
     */
    public static boolean isLengOut(String str, int leng) {
        return StrisNull(str) ? false : str.trim().length() > leng;
    }


    /**
     * 匹配是否符合正则表达式pattern 匹配返回true
     *
     * @param str     匹配的字符串
     * @param pattern 匹配模式
     * @return boolean
     */
    public static boolean Regular(String str, String pattern) {
        if (null == str || str.trim().length() <= 0) {
            return false;
        }
        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(str);
        return m.matches();
    }
}
